home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_xemacs.idb / usr / freeware / lib / xemacs-20.4 / lisp / modes / simula.el.z / simula.el
Encoding:
Text File  |  1998-05-21  |  46.4 KB  |  1,331 lines
  1. ;;; simula.el --- SIMULA 87 code editing commands for Emacs
  2.  
  3. ;; Copyright (C) 1992 Free Software Foundation, Inc.
  4.  
  5. ;; Author: Hans Henrik Eriksen <hhe@ifi.uio.no>
  6. ;; Maintainer: simula-mode@ifi.uio.no
  7. ;; Version: 0.992
  8. ;; Adapted-By: ESR
  9. ;; Keywords: languages
  10.  
  11. ;; This file is part of XEmacs.
  12.  
  13. ;; XEmacs is free software; you can redistribute it and/or modify it
  14. ;; under the terms of the GNU General Public License as published by
  15. ;; the Free Software Foundation; either version 2, or (at your option)
  16. ;; any later version.
  17.  
  18. ;; XEmacs is distributed in the hope that it will be useful, but
  19. ;; WITHOUT ANY WARRANTY; without even the implied warranty of
  20. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21. ;; General Public License for more details.
  22.  
  23. ;; You should have received a copy of the GNU General Public License
  24. ;; along with XEmacs; see the file COPYING.  If not, write to the 
  25. ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  26. ;; Boston, MA 02111-1307, USA.
  27.  
  28. ;;; Synched up with: FSF 19.30.
  29.  
  30. ;;; Commentary:
  31.  
  32. ;; A major mode for editing the Simula language.  It knows about Simula
  33. ;; syntax and standard indentation commands.  It also provides convenient
  34. ;; abbrevs for Simula keywords.
  35. ;;
  36. ;; Hans Henrik Eriksen (the author) may be reached at:
  37. ;;         Institutt for informatikk,
  38. ;;         Universitetet i Oslo
  39.  
  40. ;;; Code:
  41.  
  42. (provide 'simula-mode)
  43.  
  44. (defgroup simula nil
  45.   "SIMULA 87 code editing commands for Emacs."
  46.   :group 'languages)
  47.  
  48.  
  49. (defcustom simula-tab-always-indent nil
  50.   "*Non-nil means TAB in SIMULA mode should always reindent the current line.
  51. Otherwise TAB indents only when point is within
  52. the run of whitespace at the beginning of the line."
  53.   :type 'boolean
  54.   :group 'simula)
  55.  
  56. (defcustom simula-indent-level 3
  57.   "*Indentation of SIMULA statements with respect to containing block."
  58.   :type 'integer
  59.   :group 'simula)
  60.  
  61. (defcustom simula-substatement-offset 3
  62.   "*Extra indentation after DO, THEN, ELSE, WHEN and OTHERWISE."
  63.   :type 'integer
  64.   :group 'simula)
  65.  
  66. (defcustom simula-continued-statement-offset 3
  67.   "*Extra indentation for lines not starting a statement or substatement.
  68. If value is a list, each line in a multipleline continued statement
  69. will have the car of the list extra indentation with respect to
  70. the previous line of the statement."
  71.   :type 'integer
  72.   :group 'simula)
  73.  
  74. (defcustom simula-label-offset -4711
  75.   "*Offset of SIMULA label lines relative to usual indentation."
  76.   :type 'integer
  77.   :group 'simula)
  78.  
  79. (defcustom simula-if-indent '(0 . 0)
  80.   "*Extra indentation of THEN and ELSE with respect to the starting IF.
  81. Value is a cons cell, the car is extra THEN indentation and the cdr
  82. extra ELSE indentation.  IF after ELSE is indented as the starting IF."
  83.   :type '(cons (integer :tag "THEN")
  84.            (integer :tag "ELSE"))
  85.   :group 'simula)
  86.  
  87. (defcustom simula-inspect-indent '(0 . 0)
  88.   "*Extra indentation of WHEN and OTHERWISE with respect to the INSPECT.
  89. Value is a cons cell, the car is extra WHEN indentation
  90. and the cdr extra OTHERWISE indentation."
  91.   :type '(cons (integer :tag "WHEN")
  92.            (integer :tag "OTHERWISE"))
  93.   :group 'simula)
  94.  
  95. (defcustom simula-electric-indent nil
  96.   "*Non-nil means `simula-indent-line' function may reindent previous line."
  97.   :type 'boolean
  98.   :group 'simula)
  99.  
  100. (defcustom simula-abbrev-keyword 'upcase
  101.   "*Specify how to convert case for SIMULA keywords.
  102. Value is one of the symbols `upcase', `downcase', `capitalize',
  103. \(as in) `abbrev-table' or nil if they should not be changed."
  104.   :type '(choice (const upcase) (const downcase) (const capitalize)
  105.          (const abbrev-table) (const nil))
  106.   :group 'simula)
  107.  
  108. (defcustom simula-abbrev-stdproc 'abbrev-table
  109.   "*Specify how to convert case for standard SIMULA procedure and class names.
  110. Value is one of the symbols `upcase', `downcase', `capitalize',
  111. \(as in) `abbrev-table', or nil if they should not be changed."
  112.   :type '(choice (const upcase) (const downcase) (const capitalize)
  113.          (const abbrev-table) (const nil))
  114.   :group 'simula)
  115.  
  116. (defcustom simula-abbrev-file nil
  117.   "*File with extra abbrev definitions for use in SIMULA mode.
  118. These are used together with the standard abbrev definitions for SIMULA.
  119. Please note that the standard definitions are required
  120. for SIMULA mode to function correctly."
  121.   :type '(choice (const :tag "None")
  122.          file)
  123.   :group 'simula)
  124.  
  125. (defvar simula-mode-syntax-table nil
  126.   "Syntax table in SIMULA mode buffers.")
  127.  
  128. (if simula-mode-syntax-table
  129.     ()
  130.   (setq simula-mode-syntax-table  (copy-syntax-table nil))
  131.   (modify-syntax-entry ?!  "<"    simula-mode-syntax-table)
  132.   (modify-syntax-entry ?$  "."    simula-mode-syntax-table)
  133.   (modify-syntax-entry ?%  "."    simula-mode-syntax-table)
  134.   (modify-syntax-entry ?'  "\""   simula-mode-syntax-table)
  135.   (modify-syntax-entry ?\( "()"   simula-mode-syntax-table)
  136.   (modify-syntax-entry ?\) ")("   simula-mode-syntax-table)
  137.   (modify-syntax-entry ?\; ">"    simula-mode-syntax-table)
  138.   (modify-syntax-entry ?\[ "."    simula-mode-syntax-table)
  139.   (modify-syntax-entry ?\\ "."    simula-mode-syntax-table)
  140.   (modify-syntax-entry ?\] "."    simula-mode-syntax-table)
  141.   (modify-syntax-entry ?_  "w"    simula-mode-syntax-table)
  142.   (modify-syntax-entry ?\| "."    simula-mode-syntax-table)
  143.   (modify-syntax-entry ?\{ "."    simula-mode-syntax-table)
  144.   (modify-syntax-entry ?\} "."    simula-mode-syntax-table))
  145.  
  146. (defvar simula-mode-map ()
  147.   "Keymap used in SIMULA mode.")
  148.  
  149. (if simula-mode-map
  150.     ()
  151.   (setq simula-mode-map (make-sparse-keymap))
  152.   (define-key simula-mode-map "\C-c\C-u"   'simula-backward-up-level)
  153.   (define-key simula-mode-map "\C-c\C-p"   'simula-previous-statement)
  154.   (define-key simula-mode-map "\C-c\C-d"   'simula-forward-down-level)
  155.   (define-key simula-mode-map "\C-c\C-n"   'simula-next-statement)
  156.   ;(define-key simula-mode-map "\C-c\C-g"   'simula-goto-definition)
  157.   ;(define-key simula-mode-map "\C-c\C-h"   'simula-standard-help)
  158.   (define-key simula-mode-map ":"          'simula-electric-label)
  159.   (define-key simula-mode-map "\t"         'simula-indent-command))
  160.  
  161. (defvar simula-mode-abbrev-table nil
  162.   "Abbrev table in SIMULA mode buffers")
  163.  
  164.  
  165. (defun simula-mode ()
  166.   "Major mode for editing SIMULA code.
  167. \\{simula-mode-map}
  168. Variables controlling indentation style:
  169.  simula-tab-always-indent
  170.     Non-nil means TAB in SIMULA mode should always reindent the current line,
  171.     regardless of where in the line point is when the TAB command is used.
  172.  simula-indent-level
  173.     Indentation of SIMULA statements with respect to containing block.
  174.  simula-substatement-offset
  175.     Extra indentation after DO, THEN, ELSE, WHEN and OTHERWISE.
  176.  simula-continued-statement-offset 3
  177.     Extra indentation for lines not starting a statement or substatement,
  178.     e.g. a nested FOR-loop.  If value is a list, each line in a multiple-
  179.     line continued statement will have the car of the list extra indentation
  180.     with respect to the previous line of the statement.
  181.  simula-label-offset -4711
  182.     Offset of SIMULA label lines relative to usual indentation.
  183.  simula-if-indent '(0 . 0)
  184.     Extra indentation of THEN and ELSE with respect to the starting IF.
  185.     Value is a cons cell, the car is extra THEN indentation and the cdr
  186.     extra ELSE indentation.  IF after ELSE is indented as the starting IF.
  187.  simula-inspect-indent '(0 . 0)
  188.     Extra indentation of WHEN and OTHERWISE with respect to the
  189.     corresponding INSPECT.  Value is a cons cell, the car is
  190.     extra WHEN indentation and the cdr extra OTHERWISE indentation.
  191.  simula-electric-indent nil
  192.     If this variable is non-nil, `simula-indent-line'
  193.     will check the previous line to see if it has to be reindented.
  194.  simula-abbrev-keyword 'upcase
  195.     Determine how SIMULA keywords will be expanded.  Value is one of
  196.     the symbols `upcase', `downcase', `capitalize', (as in) `abbrev-table',
  197.     or nil if they should not be changed.
  198.  simula-abbrev-stdproc 'abbrev-table
  199.     Determine how standard SIMULA procedure and class names will be
  200.     expanded. Value is one of the symbols `upcase', `downcase', `capitalize',
  201.     (as in) `abbrev-table', or nil if they should not be changed.
  202.  
  203. Turning on SIMULA mode calls the value of the variable simula-mode-hook
  204. with no arguments, if that value is non-nil
  205.  
  206. Warning: simula-mode-hook should not read in an abbrev file without calling
  207. the function simula-install-standard-abbrevs afterwards, preferably not
  208. at all."
  209.   (interactive)
  210.   (kill-all-local-variables)
  211.   (use-local-map simula-mode-map)
  212.   (setq major-mode 'simula-mode)
  213.   (setq mode-name "SIMULA")
  214.   (make-local-variable 'comment-column)
  215.   (setq comment-column 40)
  216.   (make-local-variable 'end-comment-column)
  217.   (setq end-comment-column 75)
  218.   (set-syntax-table simula-mode-syntax-table)
  219.   (make-local-variable 'paragraph-start)
  220.   (setq paragraph-start "[ \t]*$\\|\\f")
  221.   (make-local-variable 'paragraph-separate)
  222.   (setq paragraph-separate paragraph-start)
  223.   (make-local-variable 'indent-line-function)
  224.   (setq indent-line-function 'simula-indent-line)
  225.   (make-local-variable 'require-final-newline)
  226.   (setq require-final-newline t)
  227.   (make-local-variable 'comment-start)
  228.   (setq comment-start "! ")
  229.   (make-local-variable 'comment-end)
  230.   (setq comment-end " ;")
  231.   (make-local-variable 'comment-start-skip)
  232.   (setq comment-start-skip "!+ *")
  233.   (make-local-variable 'parse-sexp-ignore-comments)
  234.   (setq parse-sexp-ignore-comments nil)
  235.   (make-local-variable 'comment-multi-line)
  236.   (setq comment-multi-line t)
  237.   (if simula-mode-abbrev-table
  238.       ()
  239.     (if simula-abbrev-file
  240.     (read-abbrev-file simula-abbrev-file)
  241.       (define-abbrev-table 'simula-mode-abbrev-table ()))
  242.     (let (abbrevs-changed)
  243.       (simula-install-standard-abbrevs)))
  244.   (setq local-abbrev-table simula-mode-abbrev-table)
  245.   (abbrev-mode 1)
  246.   (run-hooks 'simula-mode-hook))
  247.  
  248.  
  249.  
  250. (defun simula-indent-line ()
  251.   "Indent this line as SIMULA code.
  252. If `simula-electric-indent' is non-nil, indent previous line if necessary."
  253.   (let ((origin (- (point-max) (point)))
  254.     (indent (simula-calculate-indent))
  255.     (case-fold-search t))
  256.     (unwind-protect
  257.     (progn
  258.       ;;
  259.       ;; manually expand abbrev on last line, if any
  260.       ;;
  261.       (end-of-line 0)
  262.       (expand-abbrev)
  263.       ;; now maybe we should reindent that line
  264.       (if simula-electric-indent
  265.           (progn
  266.         (beginning-of-line)
  267.         (skip-chars-forward " \t\f")
  268.         (if (and
  269.              (looking-at
  270.               "\\(end\\|if\\|then\\|else\\|when\\|otherwise\\)\\>")
  271.              (not (simula-context)))
  272.             ;; yes - reindent
  273.             (let ((post-indent (simula-calculate-indent)))
  274.               (if (eq (current-indentation) post-indent)
  275.               ()
  276.             (delete-horizontal-space)
  277.             (indent-to post-indent)))))))
  278.       (goto-char (- (point-max) origin))
  279.       (if (eq (current-indentation) indent)
  280.       (back-to-indentation)
  281.     (delete-horizontal-space)
  282.     (indent-to indent)))))
  283.  
  284.  
  285. (defun simula-indent-command (&optional whole-exp)
  286.   "Indent current line as SIMULA code, or insert TAB character.
  287. If `simula-tab-always-indent' is non-nil, always indent current line.
  288. Otherwise, indent only if point is before any non-whitespace
  289. character on the line.
  290.  
  291. A numeric argument, regardless of its value, means indent rigidly
  292. all the lines of the SIMULA statement after point so that this line
  293. becomes properly indented.
  294. The relative indentation among the lines of the statement are preserved."
  295.   (interactive "P")
  296.   (let ((case-fold-search t))
  297.     (if (or whole-exp simula-tab-always-indent
  298.         (save-excursion
  299.           (skip-chars-backward " \t\f")
  300.           (bolp)))
  301.     ;; reindent current line
  302.     (let ((indent (save-excursion
  303.             (beginning-of-line)
  304.             (simula-calculate-indent)))
  305.           (current (current-indentation))
  306.           (origin (- (point-max) (point)))
  307.           (bol (save-excursion
  308.              (skip-chars-backward " \t\f")
  309.              (bolp)))
  310.           beg end)
  311.       (unwind-protect
  312.           (if (eq current indent)
  313.           (if (save-excursion
  314.             (skip-chars-backward " \t\f")
  315.             (bolp))
  316.               (back-to-indentation))
  317.         (beginning-of-line)
  318.         (delete-horizontal-space)
  319.         (indent-to indent))
  320.         (if (not bol)
  321.         (goto-char (- (point-max) origin))))
  322.       (setq origin (point))
  323.       (if whole-exp
  324.           (save-excursion
  325.         (beginning-of-line 2)
  326.         (setq beg (point))
  327.         (goto-char origin)
  328.         (simula-next-statement 1)
  329.         (setq end (point))
  330.         (if (and (> end beg) (not (eq indent current)))
  331.             (indent-code-rigidly beg end (- indent current) "%")))))
  332.       (insert-tab))))
  333.  
  334.  
  335. (defun simula-context ()
  336.   "Returns value according to syntactic SIMULA context of point.
  337.     0    point inside COMMENT comment
  338.     1    point on SIMULA-compiler directive line
  339.     2    point inside END comment
  340.     3    point inside string
  341.     4    point inside character constant
  342.   nil    otherwise."
  343.   ;; first, find out if this is a compiler directive line
  344.   (if (save-excursion
  345.     (beginning-of-line)
  346.     (eq (following-char) ?%))
  347.       ;; YES - return 1
  348.       1
  349.     (save-excursion
  350.       ;; The current line is NOT a compiler directive line.
  351.       ;; Now, the strategy is to search backward to find a semicolon
  352.       ;; that is NOT inside a string. The point after semicolon MUST be
  353.       ;; outside a comment, since semicolons are comment-ending and
  354.       ;; comments are non-recursive. We take advantage of the fact
  355.       ;; that strings MUST end on the same line as they started, so
  356.       ;; that we can easily decide whether we are inside a string or not.
  357.       (let (return-value (origin (point)))
  358.     (skip-chars-backward "^;" (point-min))
  359.     ;; found semicolon or beginning of buffer
  360.     (let (loopvalue (saved-point origin))
  361.       (while (and (not (bobp))
  362.               (if (progn
  363.                 (beginning-of-line)
  364.                 ;; compiler directive line? If so, cont searching..
  365.                 (eq (following-char) ?%))
  366.               t
  367.             (while (< (point) saved-point)
  368.               (skip-chars-forward "^;\"'")
  369.               (forward-char 1)
  370.               (cond
  371.                ((eq (preceding-char) ?\;)
  372.                 (setq saved-point (point)))
  373.                ((eq (preceding-char) ?\")
  374.                 (skip-chars-forward "^\";")
  375.                 (if (eq (following-char) ?\;)
  376.                 (setq saved-point (point) loopvalue t)
  377.                   (forward-char 1)))
  378.                (t
  379.                 (if (eq (following-char) ?')
  380.                 (forward-char 1))
  381.                 (skip-chars-forward "^';")
  382.                 (if (eq (following-char) ?\;)
  383.                 (setq saved-point (point) loopvalue t)
  384.                   (forward-char 1)))))
  385.             loopvalue))
  386.         (backward-char 1)
  387.         (skip-chars-backward "^;")
  388.         (setq saved-point (point) loopvalue nil)))
  389.     ;; Now we are CERTAIN that we are outside comments and strings.
  390.     ;; The job now is to search forward again towards the origin
  391.     ;; skipping directives, comments and strings correctly,
  392.     ;; so that we know what context we are in when we find the origin.
  393.     (while (and
  394.         (< (point) origin)
  395.         (re-search-forward
  396.          "\\<end\\>\\|!\\|\"\\|'\\|^%\\|\\<comment\\>" origin 'move))
  397.       (cond
  398.        ((memq (preceding-char) '(?d ?D))
  399.         (setq return-value 2)
  400.         (while (and (memq (preceding-char) '(?d ?D)) (not return-value))
  401.           (while (and (re-search-forward
  402.                ";\\|\\<end\\>\\|\\<else\\>\\|\\<otherwise\\>\\|\\<when\\>\\|^%"
  403.                origin 'move)
  404.               (eq (preceding-char) ?%))
  405.         (beginning-of-line 2)))
  406.         (if (looking-at "[ \t\n\f]*\\(;\\|\\<end\\>\\|\\<else\\>\\|\\<otherwise\\>\\|\\<when\\>\\)")
  407.         (setq return-value nil)))
  408.        ((memq (preceding-char) '(?! ?t ?T))
  409.         ; skip comment
  410.         (setq return-value 0)
  411.         (skip-chars-forward "^%;" origin)
  412.         (while (and return-value (< (point) origin))
  413.           (if (eq (following-char) ?\;)
  414.           (setq return-value nil)
  415.         (if (bolp)
  416.             (beginning-of-line 2)    ; skip directive inside comment
  417.           (forward-char 1))        ; or single '%'
  418.         (skip-chars-forward "^%;" origin))))
  419.        ((eq (preceding-char) ?\")
  420.         (if (not (search-forward "\"" origin 'move))
  421.         (setq return-value 3)))
  422.        ((eq (preceding-char) ?\')
  423.         (if (or (eq (point) origin) (eobp))
  424.         (setq return-value 4)
  425.           (forward-char 1)
  426.           (if (not (search-forward "'" origin 'move))
  427.           (setq return-value 4))))
  428.        ;; compiler directive line - skip
  429.        (t (beginning-of-line 2))))
  430.     return-value)
  431.       )))
  432.  
  433.  
  434. (defun simula-electric-label ()
  435.   "If this is a label that starts the line, reindent the line."
  436.   (interactive)
  437.   (expand-abbrev)
  438.   (insert ?:)
  439.   (let ((origin (- (point-max) (point)))
  440.     (case-fold-search t)
  441.     ;; don't mix a label with an assignment operator := :-
  442.     ;; therefore look at next typed character...
  443.     (next-char (if (fboundp 'next-command-event)
  444.                        (event-to-character (setq unread-command-events
  445.                                                  (list (next-command-event))))
  446.                        ;; FSFmacs
  447.                        (setq unread-command-events (list (read-event)))))
  448.     ;(com-char last-command-char) -- unused
  449.         )
  450.     (unwind-protect
  451.     ;; Problem: find out if character just read is a command char
  452.     ;; that would insert something after ':' making it a label.
  453.     ;; At least \n, \r (and maybe \t) falls into this category.
  454.     ;; This is a real crock, it depends on traditional keymap
  455.     ;; bindings, that is, printing characters doing self-insert,
  456.     ;; and no other command sequence inserting '-' or '='.
  457.     ;; simula-electric-label can be easily fooled...
  458.     (if (and (not (memq next-char '(?= ?-)))
  459.          (or (memq next-char '(?\n ?\r))
  460.              (and (eq next-char ?\t)
  461.               simula-tab-always-indent)
  462.              (not (memq (following-char) '(?= ?-))))
  463.          (not (simula-context))
  464.          ;; label?
  465.          (progn
  466.            (backward-char 1)
  467.            (skip-chars-backward " \t\f")
  468.            (skip-chars-backward "a-zA-Z0-9_")
  469.            (if (looking-at "virtual\\>")
  470.                nil
  471.              (skip-chars-backward " \t\f")
  472.              (bolp))))
  473.         (let ((amount (simula-calculate-indent)))
  474.           (delete-horizontal-space)
  475.           (indent-to amount)))
  476.       (goto-char (- (point-max) origin)))))
  477.     
  478.  
  479. (defun simula-backward-up-level (count)
  480.   "Move backward up COUNT block levels.
  481. If COUNT is negative, move forward up block level instead."
  482.   (interactive "p")
  483.   (let ((origin (point))
  484.     (case-fold-search t))
  485.     (condition-case ()
  486.     (if (> count 0)
  487.         (while (> count 0)
  488.           (re-search-backward "\\<begin\\>\\|\\<end\\>")
  489.           (if (not (simula-context))
  490.           (setq count (if (memq (following-char) '(?b ?B))
  491.                   (1- count)
  492.                 (1+ count)))))
  493.       (while (< count 0)
  494.         (re-search-forward "\\<begin\\>\\|\\<end\\>")
  495.         (backward-word 1)
  496.         (if (not (simula-context))
  497.         (setq count (if (memq (following-char) '(?e ?E))
  498.                 (1+ count)
  499.                   (1- count))))
  500.         (backward-word -1)))
  501.       ;; If block level not found, jump back to origin and signal an error
  502.       (error (progn
  503.            (goto-char origin)
  504.            (error "No higher block level")))
  505.       (quit (progn
  506.           (goto-char origin)
  507.           (signal 'quit nil))))))
  508.  
  509.  
  510. (defun simula-forward-down-level (count)
  511.   "Move forward down COUNT block levels.
  512. If COUNT is negative, move backward down block level instead."
  513.   (interactive "p")
  514.   ;; When we search for a deeper block level, we must never
  515.   ;; get out of the block where we started -> count >= start-count
  516.   (let ((start-count count)
  517.     (origin (point))
  518.     (case-fold-search t))
  519.     (condition-case ()
  520.     (if (< count 0)
  521.         (while (< count 0)
  522.           (re-search-backward "\\<begin\\>\\|\\<end\\>")
  523.           (if (not (simula-context))
  524.           (setq count (if (memq (following-char) '(?e ?E))
  525.                   (1+ count)
  526.                 (1- count))))
  527.           (if (< count start-count) (signal 'error nil)))
  528.       (while (> count 0)
  529.         (re-search-forward "\\<begin\\>\\|\\<end\\>")
  530.         (backward-word 1)
  531.         (if (not (simula-context))
  532.         (setq count (if (memq (following-char) '(?b ?B))
  533.                 (1- count)
  534.                   (1+ count))))
  535.         (backward-word -1)
  536.         ;; deeper level has to be found within starting block
  537.         (if (> count start-count) (signal 'error nil))))
  538.       ;; If block level not found, jump back to origin and signal an error
  539.       (error (progn
  540.            (goto-char origin)
  541.            (error "No containing block level")))
  542.       (quit (progn
  543.           (goto-char origin)
  544.           (signal 'quit nil))))))
  545.  
  546.      
  547. (defun simula-previous-statement (count)
  548.   "Move backward COUNT statements.
  549. If COUNT is negative, move forward instead."
  550.   (interactive "p")
  551.   (if (< count 0)
  552.       (simula-next-statement (- count))
  553.     (let (status
  554.       (case-fold-search t)
  555.       (origin (point)))
  556.       (condition-case ()
  557.       (progn
  558.         (simula-skip-comment-backward)
  559.         (if (memq (preceding-char) '(?n ?N))
  560.         (progn
  561.           (backward-word 1)
  562.           (if (not (looking-at "\\<begin\\>"))
  563.               (backward-word -1)))
  564.           (if (eq (preceding-char) ?\;)
  565.           (backward-char 1)))
  566.         (while (and (natnump (setq count (1- count)))
  567.             (setq status (simula-search-backward
  568.                       ";\\|\\<begin\\>" nil 'move))))
  569.         (if status
  570.         (progn
  571.           (if (eq (following-char) ?\;)
  572.               (forward-char 1)
  573.             (backward-word -1))))
  574.         (simula-skip-comment-forward))
  575.     (error (progn (goto-char origin)
  576.               (error "Incomplete statement (too many ENDs)")))
  577.     (quit (progn (goto-char origin) (signal 'quit nil)))))))
  578.  
  579.  
  580. (defun simula-next-statement (count)
  581.   "Move forward COUNT statements.
  582. If COUNT is negative, move backward instead."
  583.   (interactive "p")
  584.   (if (< count 0)
  585.       (simula-previous-statement (- count))
  586.     (let (status
  587.       (case-fold-search t)
  588.       (origin (point)))
  589.       (condition-case ()
  590.       (progn
  591.         (simula-skip-comment-forward)
  592.         (if (looking-at "\\<end\\>") (forward-word 1))
  593.         (while (and (natnump (setq count (1- count)))
  594.             (setq status (simula-search-forward
  595.                       ";\\|\\<end\\>" (point-max) 'move))))
  596.         (if (and status (/= (preceding-char) ?\;))
  597.         (progn
  598.           (backward-word 1)
  599.           (simula-skip-comment-backward))))
  600.     (error (progn (goto-char origin)
  601.               (error "Incomplete statement (too few ENDs)")))
  602.      (quit (progn (goto-char origin) (signal 'quit nil)))))))
  603.  
  604.  
  605. (defun simula-skip-comment-backward ()
  606.   "Search towards bob to find first char that is outside a comment."
  607.   (interactive)
  608.   (catch 'simula-out
  609.     (let (context)
  610.       (while t
  611.     (skip-chars-backward " \t\n\f")
  612.     (if (eq (preceding-char) ?\;)
  613.         (save-excursion
  614.           (backward-char 1)
  615.           (setq context (simula-context)))
  616.       (setq context (simula-context)))
  617.     (cond
  618.      ((memq context '(nil 3 4))
  619.       ;; check to see if we found a label
  620.       (if (and (eq (preceding-char) ?:)
  621.            (not (memq (following-char) '(?- ?=)))
  622.            (save-excursion
  623.              (skip-chars-backward ": \t\fa-zA-Z0-9_")
  624.              (not (looking-at "virtual\\>"))))
  625.           (skip-chars-backward ": \t\fa-zA-Z0-9_")
  626.         (throw 'simula-out nil)))
  627.      ((eq context 0)
  628.       ;; since we are inside a comment, it must start somewhere!
  629.       (while (and (re-search-backward "!\\|\\<comment\\>")
  630.               (memq (simula-context) '(0 1)))))
  631.      ((eq context 1)
  632.       (end-of-line 0)
  633.       (if (bobp)
  634.           (throw 'simula-out nil)))
  635.      ((eq context 2)
  636.       ;; an END-comment must belong to an END
  637.       (re-search-backward "\\<end\\>")
  638.       (forward-word 1)
  639.       (throw 'simula-out nil))
  640.      ;; should be impossible to get here..
  641.      )))))
  642.  
  643.  
  644. (defun simula-skip-comment-forward ()
  645.   "Search towards eob to find first char that is outside a comment."
  646.   ;; this function assumes we start with point .outside a comment
  647.   (interactive)
  648.   (catch 'simula-out
  649.     (while t
  650.       (skip-chars-forward " \t\n\f")
  651.       (cond
  652.        ((looking-at "!\\|\\<comment\\>")
  653.     (search-forward ";" nil 'move))
  654.        ((and (bolp) (eq (following-char) ?%))
  655.     (beginning-of-line 2))
  656.        ((and (looking-at "[a-z0-9_]*[ \t\f]*:[^-=]")
  657.          (not (looking-at "virtual\\>")))
  658.     (skip-chars-forward "a-zA-Z0-9_ \t\f:"))
  659.        (t
  660.     (throw 'simula-out t))))))
  661.  
  662.  
  663. (defun simula-forward-up-level ()
  664.   (let ((continue-loop t)
  665.     (origin (point))
  666.     (case-fold-search t)
  667.     return-value
  668.     temp)
  669.     (while continue-loop
  670.       (if (re-search-backward "\\<begin\\>\\|\\<end\\>" (point-min) 'move)
  671.       (setq temp (simula-context)
  672.           return-value (and (memq (preceding-char) '(?d ?D))
  673.                 (memq temp '(nil 2)))
  674.           continue-loop (and (not return-value)
  675.                  (simula-forward-up-level)))
  676.     (setq continue-loop nil)))
  677.     (if return-value
  678.     t
  679.       (goto-char origin)
  680.       nil)))
  681.  
  682.  
  683. (defun simula-calculate-indent ()
  684.   (save-excursion
  685.     (let ((where (simula-context))
  686.       (origin (point))
  687.       (indent 0)
  688.       continued
  689.       start-line
  690.       temp
  691.       found-end
  692.       prev-cont)
  693.       (cond
  694.        ((eq where 0)
  695.     ;;
  696.     ;; Comment.
  697.     ;; If comment started on previous non-blank line, indent to the
  698.     ;; column where the comment started, else indent as that line.
  699.     ;;
  700.     (skip-chars-backward " \t\n\f")
  701.     (while (and (not (bolp)) (eq (simula-context) 0))
  702.       (re-search-backward "^\\|!\\|\\<comment\\>"))
  703.     (skip-chars-forward " \t\n\f")
  704.     (prog1
  705.         (current-column)
  706.       (goto-char origin)))
  707.        ;;
  708.        ;; Detect missing string delimiters
  709.        ;;
  710.        ((eq where 3)
  711.     (error "Inside string"))
  712.        ((eq where 4)
  713.     (error "Inside character constant"))
  714.        ;;
  715.        ;; check to see if inside ()'s
  716.        ;;
  717.        ((setq temp (simula-inside-parens))
  718.     temp)
  719.        ;;
  720.        ;; Calculate non-comment indentation
  721.        (t
  722.     ;; first, find out if this line starts with something that needs
  723.     ;; special indentation (END/IF/THEN/ELSE/WHEN/OTHERWISE or label)
  724.     ;;
  725.     (skip-chars-forward " \t\f")
  726.     (cond
  727.      ;;
  728.      ;; END
  729.      ;;
  730.      ((looking-at "end\\>")
  731.       (setq indent (- simula-indent-level)
  732.         found-end t))
  733.      ;;
  734.      ;; IF/THEN/ELSE
  735.      ;;
  736.      ((looking-at "if\\>\\|then\\>\\|else\\>")
  737.       ;; search for the *starting* IF
  738.       (cond
  739.        ((memq (following-char) '(?T ?t))
  740.         (setq indent (car simula-if-indent)))
  741.        ((memq (following-char) '(?E ?e))
  742.         (setq indent (cdr simula-if-indent)))
  743.        (t
  744.         (forward-word 1)
  745.         (setq indent 0)))
  746.       (simula-find-if))
  747.      ;;
  748.      ;; WHEN/OTHERWISE
  749.      ;;
  750.      ((looking-at "when\\>\\|otherwise\\>")
  751.       ;; search for corresponding INSPECT
  752.       (if (memq (following-char) '(?W ?w))
  753.           (setq indent (car simula-inspect-indent))
  754.         (setq indent (cdr simula-inspect-indent)))
  755.       (simula-find-inspect))
  756.      ;;
  757.      ;; label:
  758.      ;;
  759.      ((and (not (looking-at "virtual\\>"))
  760.            (looking-at "[a-z0-9_]*[ \t\f]*:[^-=]"))
  761.       (setq indent simula-label-offset)))
  762.     ;; find line with non-comment text
  763.     (simula-skip-comment-backward)
  764.     (if (and found-end
  765.          (not (eq (preceding-char) ?\;))
  766.          (if (memq (preceding-char) '(?N ?n))
  767.              (save-excursion
  768.                (backward-word 1)
  769.                (not (looking-at "begin\\>")))
  770.            t))
  771.         (progn
  772.           (simula-previous-statement 1)
  773.           (simula-skip-comment-backward)))
  774.     (setq start-line
  775.           (save-excursion (beginning-of-line) (point))
  776.           ;; - perhaps this is a continued statement
  777.           continued
  778.           (save-excursion
  779.         (and (not (bobp))
  780.              ;; (not found-end)
  781.              (if (eq (char-syntax (preceding-char)) ?w)
  782.              (progn
  783.                (backward-word 1)
  784.                (not (looking-at
  785.                  "begin\\|then\\|else\\|when\\|otherwise\\|do"
  786.                  )))
  787.                (not (memq (preceding-char) '(?: ?\;)))))))
  788.     ;;
  789.     ;; MAIN calculation loop - count BEGIN/DO etc.
  790.     ;;
  791.     (while (not (bolp))
  792.       (if (re-search-backward
  793.            ";\\|\\<\\(begin\\|end\\|if\\|else\\|then\\|when\\|otherwise\\|do\\)\\>"
  794.            start-line 'move)
  795.           (if (simula-context)
  796.           ();; found something in a comment/string - ignore
  797.         (setq temp (following-char))
  798.         (cond
  799.          ((eq temp ?\;)
  800.           (simula-previous-statement 1))
  801.          ((looking-at "begin\\>")
  802.           (setq indent (+ indent simula-indent-level)))
  803.          ((looking-at "end\\>")
  804.           (forward-word 1)
  805.           (simula-previous-statement 1))
  806.          ((looking-at "do\\>")
  807.           (setq indent (+ indent simula-substatement-offset))
  808.           (simula-find-do-match))
  809.          ((looking-at "\\(if\\|then\\|else\\)\\>")
  810.           (if (memq temp '(?I ?i))
  811.               (forward-word 1)
  812.             (setq indent (+ indent
  813.                     simula-substatement-offset
  814.                     (if (memq temp '(?T ?t))
  815.                     (car simula-if-indent)
  816.                       (cdr simula-if-indent)))))
  817.           (simula-find-if))
  818.          ((looking-at "\\<when\\>\\|\\<otherwise\\>")
  819.           (setq indent (+ indent
  820.                   simula-substatement-offset
  821.                   (if (memq temp '(?W ?w))
  822.                       (car simula-if-indent)
  823.                     (cdr simula-if-indent))))
  824.           (simula-find-inspect)))
  825.         ;; found the start of a [sub]statement
  826.         ;; add indentation for continued statement
  827.         (if continued
  828.             (setq indent
  829.               (+ indent
  830.                  (if (listp simula-continued-statement-offset)
  831.                  (car simula-continued-statement-offset)
  832.                    simula-continued-statement-offset))))
  833.         (setq start-line
  834.               (save-excursion (beginning-of-line) (point))
  835.               continued nil))
  836.         ;; search failed .. point is at beginning of line
  837.         ;; determine if we should continue searching
  838.         ;; (at or before comment or label)
  839.         ;; temp = t means finished
  840.         (setq temp
  841.           (and (not (simula-context))            
  842.                (save-excursion
  843.              (skip-chars-forward " \t\f")
  844.              (or (looking-at "virtual")
  845.                  (not
  846.                   (looking-at
  847.                    "!\\|comment\\>\\|[a-z0-9_]*[ \t\f]*:[^-=]")))))
  848.           prev-cont continued)
  849.         ;; if we are finished, find current line's indentation
  850.         (if temp
  851.         (setq indent (+ indent (current-indentation))))
  852.         ;; find next line with non-comment SIMULA text
  853.         ;; maybe indent extra if statement continues
  854.         (simula-skip-comment-backward)
  855.         (setq continued
  856.           (and (not (bobp))
  857.                (if (eq (char-syntax (preceding-char)) ?w)
  858.                (save-excursion
  859.                  (backward-word 1)
  860.                  (not (looking-at
  861.                    "begin\\|then\\|else\\|when\\|otherwise\\|do")))
  862.              (not (memq (preceding-char) '(?: ?\;))))))
  863.         ;; if we the state of the continued-variable
  864.         ;; changed, add indentation for continued statement
  865.         (if (or (and prev-cont (not continued))
  866.             (and continued
  867.              (listp simula-continued-statement-offset)))
  868.         (setq indent
  869.               (+ indent
  870.              (if (listp simula-continued-statement-offset)
  871.                  (car simula-continued-statement-offset)
  872.                simula-continued-statement-offset))))
  873.         ;; while ends if point is at beginning of line at loop test
  874.         (if (not temp)
  875.         (setq start-line (save-excursion (beginning-of-line) (point)))
  876.           (beginning-of-line))))
  877.         ;;
  878.     ;; return indentation
  879.     ;;
  880.     indent)))))
  881.  
  882.  
  883. (defun simula-find-if ()
  884.   "Find starting IF of a IF-THEN[-ELSE[-IF-THEN...]] statement."
  885.   (catch 'simula-out
  886.     (while t
  887.       (if (and (simula-search-backward "\\<if\\>\\|;\\|\\<begin\\>"nil t)
  888.            (memq (following-char) '(?I ?i)))
  889.       (save-excursion
  890.         ;;
  891.         ;; find out if this IF was really the start of the IF statement
  892.         ;;
  893.         (simula-skip-comment-backward)
  894.         (if (and (eq (char-syntax (preceding-char)) ?w)
  895.              (progn
  896.                (backward-word 1)
  897.                (looking-at "else\\>")))
  898.         ()
  899.           (throw 'simula-out t)))
  900.     (if (not (looking-at "\\<if\\>"))
  901.         (error "Missing IF or misplaced BEGIN or ';' (can't find IF)")
  902.       ;;
  903.       ;; we were at the starting IF in the first place..
  904.       ;;
  905.       (throw 'simula-out t))))))
  906.  
  907.  
  908. (defun simula-find-inspect ()
  909.   "Find INSPECT matching WHEN or OTHERWISE."
  910.   (catch 'simula-out
  911.     (let ((level 0))
  912.       ;;
  913.       ;; INSPECTs can be nested, have to find the corresponding one
  914.       ;;
  915.       (while t
  916.     (if (and (simula-search-backward "\\<inspect\\>\\|\\<otherwise\\>\\|;"
  917.                       nil t)
  918.          (/= (following-char) ?\;))
  919.         (if (memq (following-char) '(?O ?o))
  920.         (setq level (1+ level))
  921.           (if (zerop level)
  922.           (throw 'simula-out t)
  923.         (setq level (1- level))))
  924.       (error "Missing INSPECT or misplaced ';' (can't find INSPECT)"))))))
  925.  
  926.  
  927. (defun simula-find-do-match ()
  928.   "Find keyword matching DO: FOR, WHILE, INSPECT or WHEN"
  929.   (while (and (re-search-backward
  930.            "\\<\\(do\\|for\\|while\\|inspect\\|when\\|end\\|begin\\)\\>\\|;"
  931.            nil 'move)
  932.           (simula-context)))
  933.   (if (and (looking-at "\\<\\(for\\|while\\|inspect\\|when\\)\\>")
  934.        (not (simula-context)))
  935.       () ;; found match
  936.     (error "No matching FOR, WHILE or INSPECT for DO, or misplaced ';'")))
  937.  
  938.  
  939. (defun simula-inside-parens ()
  940.   "Return position after `(' on line if inside parentheses, nil otherwise."
  941.   (save-excursion
  942.     (let ((parlevel 0))
  943.       (catch 'simula-out
  944.     (while t
  945.       (if (re-search-backward "(\\|)\\|;" nil t)
  946.           (if (eq (simula-context) nil)
  947.           ;; found something - check it out
  948.           (cond
  949.            ((eq (following-char) ?\;)
  950.             (if (zerop parlevel)
  951.             (throw 'simula-out nil)
  952.               (error "Parenthesis mismatch or misplaced ';'")))
  953.            ((eq (following-char) ?\()
  954.             (if (zerop parlevel)
  955.             (throw 'simula-out (1+ (current-column)))
  956.               (setq parlevel (1- parlevel))))
  957.            (t (setq parlevel (1+ parlevel))))
  958.         );; nothing - inside comment or string
  959.         ;; search failed
  960.         (throw 'simula-out nil)))))))
  961.  
  962.  
  963. (defun simula-goto-definition ()
  964.   "Goto point of definition of variable, procedure or class."
  965.   (interactive))
  966.  
  967.  
  968. (defun simula-expand-stdproc ()
  969.   (if (or (not simula-abbrev-stdproc) (simula-context))
  970.       (unexpand-abbrev)
  971.     (cond
  972.      ((eq simula-abbrev-stdproc 'upcase) (upcase-word -1))
  973.      ((eq simula-abbrev-stdproc 'downcase) (downcase-word -1))
  974.      ((eq simula-abbrev-stdproc 'capitalize) (capitalize-word -1)))))
  975.  
  976.  
  977. (defun simula-expand-keyword ()
  978.   (if (or (not simula-abbrev-keyword) (simula-context))
  979.       (unexpand-abbrev)
  980.     (cond
  981.      ((eq simula-abbrev-keyword 'upcase) (upcase-word -1))
  982.      ((eq simula-abbrev-keyword 'downcase) (downcase-word -1))
  983.      ((eq simula-abbrev-keyword 'capitalize) (capitalize-word -1)))))
  984.  
  985.  
  986. (defun simula-electric-keyword ()
  987.   "Expand SIMULA keyword.  If it starts the line, reindent."
  988.   ;; redisplay
  989.   (let ((show-char (eq this-command 'self-insert-command)))
  990.     ;; If the abbrev expansion results in reindentation, the user may have
  991.     ;; to wait some time before the character he typed is displayed
  992.     ;; (the char causing the expansion is inserted AFTER the hook function
  993.     ;; is called). This is annoying in case of normal characters.
  994.     ;; However, if the user pressed a key bound to newline, it is better
  995.     ;; to have the line inserted after the begin-end match.
  996.     (if show-char
  997.     (progn
  998.       (insert-char last-command-char 1)
  999.       (sit-for 0)
  1000.       (backward-char 1)))
  1001.     (if (let ((where (simula-context))
  1002.           (case-fold-search t))
  1003.       (if where
  1004.           (if (and (eq where 2) (eq (char-syntax (preceding-char)) ?w))
  1005.           (save-excursion
  1006.             (backward-word 1)
  1007.             (not (looking-at "end\\>"))))))
  1008.     (unexpand-abbrev)
  1009.       (cond
  1010.        ((not simula-abbrev-keyword) (unexpand-abbrev))
  1011.        ((eq simula-abbrev-keyword 'upcase) (upcase-word -1))
  1012.        ((eq simula-abbrev-keyword 'downcase) (downcase-word -1))
  1013.        ((eq simula-abbrev-keyword 'capitalize) (capitalize-word -1)))
  1014.       (let ((pos (- (point-max) (point)))
  1015.         (case-fold-search t)
  1016.         )
  1017.     (condition-case nil
  1018.         (progn
  1019.           ;; check if the expanded word is on the beginning of the line.
  1020.           (if (and (eq (char-syntax (preceding-char)) ?w)
  1021.                (progn
  1022.              (backward-word 1)
  1023.              (if (looking-at "end\\>")
  1024.                  (save-excursion
  1025.                    (simula-backward-up-level 1)
  1026.                    (if (pos-visible-in-window-p)
  1027.                    (sit-for 1)
  1028.                  (message
  1029.                   (concat "Matches "
  1030.                       (buffer-substring
  1031.                        (point)
  1032.                        (+ (point) (window-width))))))))
  1033.              (skip-chars-backward " \t\f")
  1034.              (bolp)))
  1035.           (let ((indent (simula-calculate-indent)))
  1036.             (if (eq indent (current-indentation))
  1037.             ()
  1038.               (delete-horizontal-space)
  1039.               (indent-to indent)))
  1040.         (skip-chars-forward " \t\f"))
  1041.           ;; check for END - blow whistles and ring bells
  1042.  
  1043.           (goto-char (- (point-max) pos))
  1044.           (if show-char
  1045.           (delete-char 1)))
  1046.       (quit (goto-char (- (point-max) pos))))))))
  1047.  
  1048.  
  1049. (defun simula-search-backward (string &optional limit move)
  1050.   (setq string (concat string "\\|\\<end\\>"))
  1051.   (let (level)
  1052.     (catch 'simula-out
  1053.       (while (re-search-backward string limit move)
  1054.     (if (simula-context)
  1055.         ()
  1056.       (if (looking-at "\\<end\\>")
  1057.               (progn
  1058.                 (setq level 0)
  1059.                 (while (natnump level)
  1060.                   (re-search-backward "\\<begin\\>\\|\\<end\\>")
  1061.                   (if (simula-context)
  1062.                       ()
  1063.                     (setq level (if (memq (following-char) '(?b ?B))
  1064.                                     (1- level)
  1065.                                   (1+ level))))))
  1066.             (throw 'simula-out t)))))))
  1067.  
  1068.  
  1069. (defun simula-search-forward (string &optional limit move)
  1070.   (setq string (concat string "\\|\\<begin\\>"))
  1071.   (let (level)
  1072.     (catch 'exit
  1073.       (while (re-search-forward string limit move)
  1074.     (goto-char (match-beginning 0))
  1075.     (if (simula-context)
  1076.         (goto-char (1- (match-end 0)))
  1077.       (if (looking-at "\\<begin\\>")
  1078.           (progn
  1079.         (goto-char (1- (match-end 0)))
  1080.         (setq level 0)
  1081.         (while (natnump level)
  1082.           (re-search-forward "\\<begin\\>\\|\\<end\\>")
  1083.           (backward-word 1)
  1084.           (if (not (simula-context))
  1085.               (setq level (if (memq (following-char) '(?e ?E))
  1086.                       (1- level)
  1087.                     (1+ level))))
  1088.           (backward-word -1)))
  1089.         (goto-char (1- (match-end 0)))
  1090.         (throw 'exit t)))))))
  1091.  
  1092.   
  1093. (defun simula-install-standard-abbrevs ()
  1094.   "Define Simula keywords, procedures and classes in local abbrev table."
  1095.   ;; procedure and class names are as of the SIMULA 87 standard.
  1096.   (interactive)
  1097.   (mapcar (function (lambda (args)
  1098.               (apply 'define-abbrev simula-mode-abbrev-table args)))
  1099.       '(("abs" "Abs" simula-expand-stdproc)
  1100.         ("accum" "Accum" simula-expand-stdproc)
  1101.         ("activate" "ACTIVATE" simula-expand-keyword)
  1102.         ("addepsilon" "AddEpsilon" simula-expand-stdproc)
  1103.         ("after" "AFTER" simula-expand-keyword)
  1104.         ("and" "AND" simula-expand-keyword)
  1105.         ("arccos" "ArcCos" simula-expand-stdproc)
  1106.         ("arcsin" "ArcSin" simula-expand-stdproc)
  1107.         ("arctan" "ArcTan" simula-expand-stdproc)
  1108.         ("arctan2" "ArcTan2" simula-expand-stdproc)
  1109.         ("array" "ARRAY" simula-expand-keyword)
  1110.         ("at" "AT" simula-expand-keyword)
  1111.         ("before" "BEFORE" simula-expand-keyword)
  1112.         ("begin" "BEGIN" simula-expand-keyword)
  1113.         ("blanks" "Blanks" simula-expand-stdproc)
  1114.         ("boolean" "BOOLEAN" simula-expand-keyword)
  1115.         ("breakoutimage" "BreakOutImage" simula-expand-stdproc)
  1116.         ("bytefile" "ByteFile" simula-expand-stdproc)
  1117.         ("call" "Call" simula-expand-stdproc)
  1118.         ("cancel" "Cancel" simula-expand-stdproc)
  1119.         ("cardinal" "Cardinal" simula-expand-stdproc)
  1120.         ("char" "Char" simula-expand-stdproc)
  1121.         ("character" "CHARACTER" simula-expand-keyword)
  1122.         ("checkpoint" "CheckPoint" simula-expand-stdproc)
  1123.         ("class" "CLASS" simula-expand-keyword)
  1124.         ("clear" "Clear" simula-expand-stdproc)
  1125.         ("clocktime" "ClockTime" simula-expand-stdproc)
  1126.         ("close" "Close" simula-expand-stdproc)
  1127.         ("comment" "COMMENT" simula-expand-keyword)
  1128.         ("constant" "Constant" simula-expand-stdproc)
  1129.         ("copy" "Copy" simula-expand-stdproc)
  1130.         ("cos" "Cos" simula-expand-stdproc)
  1131.         ("cosh" "CosH" simula-expand-stdproc)
  1132.         ("cotan" "CoTan" simula-expand-stdproc)
  1133.         ("cputime" "CpuTime" simula-expand-stdproc)
  1134.         ("current" "Current" simula-expand-stdproc)
  1135.         ("datetime" "DateTime" simula-expand-stdproc)
  1136.         ("decimalmark" "DecimalMark" simula-expand-stdproc)
  1137.         ("delay" "DELAY" simula-expand-keyword)
  1138.         ("deleteimage" "DeleteImage" simula-expand-stdproc)
  1139.         ("detach" "Detach" simula-expand-stdproc)
  1140.         ("digit" "Digit" simula-expand-stdproc)
  1141.         ("directbytefile" "DirectByteFile" simula-expand-stdproc)
  1142.         ("directfile" "DirectFile" simula-expand-stdproc)
  1143.         ("discrete" "Discrete" simula-expand-stdproc)
  1144.         ("do" "DO" simula-expand-keyword)
  1145.         ("downcase" "Downcase" simula-expand-stdproc)
  1146.         ("draw" "Draw" simula-expand-stdproc)
  1147.         ("eject" "Eject" simula-expand-stdproc)
  1148.         ("else" "ELSE" simula-electric-keyword)
  1149.         ("empty" "Empty" simula-expand-stdproc)
  1150.         ("end" "END" simula-electric-keyword)
  1151.         ("endfile" "Endfile" simula-expand-stdproc)
  1152.         ("entier" "Entier" simula-expand-stdproc)
  1153.         ("eq" "EQ" simula-expand-keyword)
  1154.         ("eqv" "EQV" simula-expand-keyword)
  1155.         ("erlang" "Erlang" simula-expand-stdproc)
  1156.         ("error" "Error" simula-expand-stdproc)
  1157.         ("evtime" "EvTime" simula-expand-stdproc)
  1158.         ("exp" "Exp" simula-expand-stdproc)
  1159.         ("external" "EXTERNAL" simula-expand-keyword)
  1160.         ("false" "FALSE" simula-expand-keyword)
  1161.         ("field" "Field" simula-expand-stdproc)
  1162.         ("file" "File" simula-expand-stdproc)
  1163.         ("first" "First" simula-expand-stdproc)
  1164.         ("follow" "Follow" simula-expand-stdproc)
  1165.         ("for" "FOR" simula-expand-keyword)
  1166.         ("ge" "GE" simula-expand-keyword)
  1167.         ("getchar" "GetChar" simula-expand-stdproc)
  1168.         ("getfrac" "GetFrac" simula-expand-stdproc)
  1169.         ("getint" "GetInt" simula-expand-stdproc)
  1170.         ("getreal" "GetReal" simula-expand-stdproc)
  1171.         ("go" "GO" simula-expand-keyword)
  1172.         ("goto" "GOTO" simula-expand-keyword)
  1173.         ("gt" "GT" simula-expand-keyword)
  1174.         ("head" "Head" simula-expand-stdproc)
  1175.         ("hidden" "HIDDEN" simula-expand-keyword)
  1176.         ("histd" "HistD" simula-expand-stdproc)
  1177.         ("histo" "Histo" simula-expand-stdproc)
  1178.         ("hold" "Hold" simula-expand-stdproc)
  1179.         ("idle" "Idle" simula-expand-stdproc)
  1180.         ("if" "IF" simula-expand-keyword)
  1181.         ("image" "Image" simula-expand-stdproc)
  1182.         ("imagefile" "ImageFile" simula-expand-stdproc)
  1183.         ("imp" "IMP" simula-expand-keyword)
  1184.         ("in" "IN" simula-expand-keyword)
  1185.         ("inbyte" "InByte" simula-expand-stdproc)
  1186.         ("inbytefile" "InByteFile" simula-expand-stdproc)
  1187.         ("inchar" "InChar" simula-expand-stdproc)
  1188.         ("infile" "InFile" simula-expand-stdproc)
  1189.         ("infrac" "InFrac" simula-expand-stdproc)
  1190.         ("inimage" "InImage" simula-expand-stdproc)
  1191.         ("inint" "InInt" simula-expand-stdproc)
  1192.         ("inner" "INNER" simula-expand-keyword)
  1193.         ("inreal" "InReal" simula-expand-stdproc)
  1194.         ("inrecord" "InRecord" simula-expand-stdproc)
  1195.         ("inspect" "INSPECT" simula-expand-keyword)
  1196.         ("integer" "INTEGER" simula-expand-keyword)
  1197.         ("intext" "InText" simula-expand-stdproc)
  1198.         ("into" "Into" simula-expand-stdproc)
  1199.         ("is" "IS" simula-expand-keyword)
  1200.         ("isochar" "ISOChar" simula-expand-stdproc)
  1201.         ("isopen" "IsOpen" simula-expand-stdproc)
  1202.         ("isorank" "ISORank" simula-expand-stdproc)
  1203.         ("label" "LABEL" simula-expand-keyword)
  1204.         ("last" "Last" simula-expand-stdproc)
  1205.         ("lastitem" "LastItem" simula-expand-stdproc)
  1206.         ("lastloc" "LastLoc" simula-expand-stdproc)
  1207.         ("le" "LE" simula-expand-keyword)
  1208.         ("length" "Length" simula-expand-stdproc)
  1209.         ("letter" "Letter" simula-expand-stdproc)
  1210.         ("line" "Line" simula-expand-stdproc)
  1211.         ("linear" "Linear" simula-expand-stdproc)
  1212.         ("linesperpage" "LinesPerPage" simula-expand-stdproc)
  1213.         ("link" "Link" simula-expand-stdproc)
  1214.         ("linkage" "Linkage" simula-expand-stdproc)
  1215.         ("ln" "Ln" simula-expand-stdproc)
  1216.         ("locate" "Locate" simula-expand-stdproc)
  1217.         ("location" "Location" simula-expand-stdproc)
  1218.         ("lock" "Lock" simula-expand-stdproc)
  1219.         ("locked" "Locked" simula-expand-stdproc)
  1220.         ("log10" "Log10" simula-expand-stdproc)
  1221.         ("long" "LONG" simula-expand-keyword)
  1222.         ("lowcase" "LowCase" simula-expand-stdproc)
  1223.         ("lowerbound" "LowerBound" simula-expand-stdproc)
  1224.         ("lowten" "LowTen" simula-expand-stdproc)
  1225.         ("lt" "LT" simula-expand-keyword)
  1226.         ("main" "Main" simula-expand-stdproc)
  1227.         ("max" "Max" simula-expand-stdproc)
  1228.         ("maxint" "MaxInt" simula-expand-stdproc)
  1229.         ("maxlongreal" "MaxLongReal" simula-expand-stdproc)
  1230.         ("maxloc" "MaxLoc" simula-expand-stdproc)
  1231.         ("maxrank" "MaxRank" simula-expand-stdproc)
  1232.         ("maxreal" "MaxReal" simula-expand-stdproc)
  1233.         ("min" "Min" simula-expand-stdproc)
  1234.         ("minint" "MinInt" simula-expand-stdproc)
  1235.         ("minlongreal" "MinLongReal" simula-expand-stdproc)
  1236.         ("minrank" "MinRank" simula-expand-stdproc)
  1237.         ("minreal" "MinReal" simula-expand-stdproc)
  1238.         ("mod" "Mod" simula-expand-stdproc)
  1239.         ("more" "More" simula-expand-stdproc)
  1240.         ("name" "NAME" simula-expand-keyword)
  1241.         ("ne" "NE" simula-expand-keyword)
  1242.         ("negexp" "NegExp" simula-expand-stdproc)
  1243.         ("new" "NEW" simula-expand-keyword)
  1244.         ("nextev" "NextEv" simula-expand-stdproc)
  1245.         ("none" "NONE" simula-expand-keyword)
  1246.         ("normal" "Normal" simula-expand-stdproc)
  1247.         ("not" "NOT" simula-expand-keyword)
  1248.         ("notext" "NOTEXT" simula-expand-keyword)
  1249.         ("open" "Open" simula-expand-stdproc)
  1250.         ("or" "OR" simula-expand-keyword)
  1251.         ("otherwise" "OTHERWISE" simula-electric-keyword)
  1252.         ("out" "Out" simula-expand-stdproc)
  1253.         ("outbyte" "OutByte" simula-expand-stdproc)
  1254.         ("outbytefile" "OutByteFile" simula-expand-stdproc)
  1255.         ("outchar" "OutChar" simula-expand-stdproc)
  1256.         ("outfile" "OutFile" simula-expand-stdproc)
  1257.         ("outfix" "OutFix" simula-expand-stdproc)
  1258.         ("outfrac" "OutFrac" simula-expand-stdproc)
  1259.         ("outimage" "OutImage" simula-expand-stdproc)
  1260.         ("outint" "OutInt" simula-expand-stdproc)
  1261.         ("outreal" "OutReal" simula-expand-stdproc)
  1262.         ("outrecord" "OutRecord" simula-expand-stdproc)
  1263.         ("outtext" "OutText" simula-expand-stdproc)
  1264.         ("page" "Page" simula-expand-stdproc)
  1265.         ("passivate" "Passivate" simula-expand-stdproc)
  1266.         ("poisson" "Poisson" simula-expand-stdproc)
  1267.         ("pos" "Pos" simula-expand-stdproc)
  1268.         ("precede" "Precede" simula-expand-stdproc)
  1269.         ("pred" "Pred" simula-expand-stdproc)
  1270.         ("prev" "Prev" simula-expand-stdproc)
  1271.         ("printfile" "PrintFile" simula-expand-stdproc)
  1272.         ("prior" "PRIOR" simula-expand-keyword)
  1273.         ("procedure" "PROCEDURE" simula-expand-keyword)
  1274.         ("process" "Process" simula-expand-stdproc)
  1275.         ("protected" "PROTECTED" simula-expand-keyword)
  1276.         ("putchar" "PutChar" simula-expand-stdproc)
  1277.         ("putfix" "PutFix" simula-expand-stdproc)
  1278.         ("putfrac" "PutFrac" simula-expand-stdproc)
  1279.         ("putint" "PutInt" simula-expand-stdproc)
  1280.         ("putreal" "PutReal" simula-expand-stdproc)
  1281.         ("qua" "QUA" simula-expand-keyword)
  1282.         ("randint" "RandInt" simula-expand-stdproc)
  1283.         ("rank" "Rank" simula-expand-stdproc)
  1284.         ("reactivate" "REACTIVATE" simula-expand-keyword)
  1285.         ("real" "REAL" simula-expand-keyword)
  1286.         ("ref" "REF" simula-expand-keyword)
  1287.         ("resume" "Resume" simula-expand-stdproc)
  1288.         ("setaccess" "SetAccess" simula-expand-stdproc)
  1289.         ("setpos" "SetPos" simula-expand-stdproc)
  1290.         ("short" "SHORT" simula-expand-keyword)
  1291.         ("sign" "Sign" simula-expand-stdproc)
  1292.         ("simset" "SimSet" simula-expand-stdproc)
  1293.         ("simulaid" "SimulaId" simula-expand-stdproc)
  1294.         ("simulation" "Simulation" simula-expand-stdproc)
  1295.         ("sin" "Sin" simula-expand-stdproc)
  1296.         ("sinh" "SinH" simula-expand-stdproc)
  1297.         ("sourceline" "SourceLine" simula-expand-stdproc)
  1298.         ("spacing" "Spacing" simula-expand-stdproc)
  1299.         ("sqrt" "Sqrt" simula-expand-stdproc)
  1300.         ("start" "Start" simula-expand-stdproc)
  1301.         ("step" "STEP" simula-expand-keyword)
  1302.         ("strip" "Strip" simula-expand-stdproc)
  1303.         ("sub" "Sub" simula-expand-stdproc)
  1304.         ("subepsilon" "SubEpsilon" simula-expand-stdproc)
  1305.         ("suc" "Suc" simula-expand-stdproc)
  1306.         ("switch" "SWITCH" simula-expand-keyword)
  1307.         ("sysin" "SysIn" simula-expand-stdproc)
  1308.         ("sysout" "SysOut" simula-expand-stdproc)
  1309.         ("tan" "Tan" simula-expand-stdproc)
  1310.         ("tanh" "TanH" simula-expand-stdproc)
  1311.         ("terminate_program" "Terminate_Program" simula-expand-stdproc)
  1312.         ("terminated" "Terminated" simula-expand-stdproc)
  1313.         ("text" "TEXT" simula-expand-keyword)
  1314.         ("then" "THEN" simula-electric-keyword)
  1315.         ("this" "THIS" simula-expand-keyword)
  1316.         ("time" "Time" simula-expand-stdproc)
  1317.         ("to" "TO" simula-expand-keyword)
  1318.         ("true" "TRUE" simula-expand-keyword)
  1319.         ("uniform" "Uniform" simula-expand-stdproc)
  1320.         ("unlock" "Unlock" simula-expand-stdproc)
  1321.         ("until" "UNTIL" simula-expand-keyword)
  1322.         ("upcase" "Upcase" simula-expand-stdproc)
  1323.         ("upperbound" "UpperBound" simula-expand-stdproc)
  1324.         ("value" "VALUE" simula-expand-keyword)
  1325.         ("virtual" "VIRTUAL" simula-expand-keyword)
  1326.         ("wait" "Wait" simula-expand-stdproc)
  1327.         ("when" "WHEN" simula-electric-keyword)
  1328.         ("while" "WHILE" simula-expand-keyword))))
  1329.  
  1330. ;;; simula.el ends here
  1331.